/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package br.com.foxinline.util;

import br.com.foxinline.generico.EntidadeGenerica;
import br.com.foxinline.modelo.Anexo;
import br.com.foxinline.modelo.Endereco;
import br.com.foxinline.modelo.Proprietario;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;

/**
 *
 * @author nayra
 */
public class MergeUtilitario {

    public static ProprietarioMerge mergeProprietario(ProprietarioMerge pm, Boolean isConjuge) {
        //Campos
        for (Campo<?> cp : pm.getCampos()) {
            if (cp.getUsarAlteracao()) {
                setPrivateField(pm.getPropInclusao(), cp.getField(), cp.getVlrAlteracao());
            }
        }

        //Endereco Proprietario
        if (pm.getEnderecoIncluido() != null && pm.getUsarEnderecoIncluido()) {
            Endereco e = pm.getEnderecoIncluido().getClone();
            e.setId(null);
            e = (Endereco) setCamposNulos(e);
            pm.getPropInclusao().setEndereco(e);
        } else if (pm.getcEndereco() != null) {
            //Campos Endereco
            if (pm.getcEndereco() != null && !pm.getcEndereco().isEmpty()) {
                for (Campo<?> cp : pm.getcEndereco()) {
                    if (cp.getUsarAlteracao()) {
                        setPrivateField(pm.getPropInclusao().getEndereco(), cp.getField(), cp.getVlrAlteracao());
                    }
                }
            }
        }

        //Anexos
        if (pm.getPropInclusao().getAnexos() == null && !pm.getAnexosIncluidos().isEmpty()) {
            pm.getPropInclusao().setAnexos(new ArrayList<Anexo>());
        }
        for (Campo<Anexo> cp : pm.getAnexosIncluidos()) {
            if (cp.getUsarAlteracao()) {
                Anexo a = copiaAnexo(cp.getVlrAlteracao());

                File original = new File(a.getUrl() + a.getNome());
                a.setArquivo(getBytes(original));

                ArquivoUtilitario au = new ArquivoUtilitario();
                a = au.gravarAnexoCopia(a);

                a.setId(null);
                a = (Anexo) setCamposNulos(a);
                pm.getPropInclusao().getAnexos().add(a);
            }
        }

        //Conjuge Proprietario
        if (!isConjuge) {
            if (pm.getConjugeIncluido() != null && pm.getUsarConjugeIncluido()) {
                Proprietario c = cloneProprietario(pm.getConjugeIncluido().getVlrAlteracao(), true);
                pm.getPropInclusao().setConjuge(c);
            } else if (pm.getConjugeMerge() != null) {
                pm.setConjugeMerge(mergeProprietario(pm.getConjugeMerge(), true));
                pm.getPropInclusao().setConjuge(pm.getConjugeMerge().getPropInclusao());
            }
        }

        return pm;
    }

    public static Proprietario cloneProprietario(Proprietario proprietario, Boolean isConjuge) {
        Proprietario p = proprietario.getClone();
        p.setId(null);
        p = (Proprietario) setCamposNulos(p);

        if (isConjuge) {
            p.setEstadoCivil(null);
        }

        if (p.getEndereco() != null) {
            Endereco e = p.getEndereco().getClone();
            e.setId(null);
            e = (Endereco) setCamposNulos(e);
            p.setEndereco(e);
        }

        List<Anexo> anexos = new ArrayList<Anexo>();
        if (p.getAnexos() != null) {
            for (Anexo anexo : p.getAnexos()) {
                Anexo a = copiaAnexo(anexo);
                File original = new File(a.getUrl() + a.getNome());
                a.setArquivo(getBytes(original));

                ArquivoUtilitario au = new ArquivoUtilitario();
                a = au.gravarAnexoCopia(a);

                a.setId(null);
                a = (Anexo) setCamposNulos(a);
                anexos.add(a);
            }
        }
        p.setAnexos(anexos);


        if (!isConjuge) {
            if (p.getConjuge() != null) {
                Proprietario conj = p.getConjuge().getClone();
                conj.setId(null);
                conj = (Proprietario) setCamposNulos(conj);
                conj.setEstadoCivil(null);
                conj.setConjuge(null);

                if (conj.getEndereco() != null) {
                    Endereco e = conj.getEndereco().getClone();
                    e.setId(null);
                    e = (Endereco) setCamposNulos(e);
                    conj.setEndereco(e);
                }

                List<Anexo> anxs = new ArrayList<Anexo>();
                if (conj.getAnexos() != null) {
                    for (Anexo anexo : conj.getAnexos()) {
                        Anexo a = copiaAnexo(anexo);
                        File original = new File(a.getUrl() + a.getNome());
                        a.setArquivo(getBytes(original));

                        ArquivoUtilitario au = new ArquivoUtilitario();
                        a = au.gravarAnexoCopia(a);

                        a.setId(null);
                        a = (Anexo) setCamposNulos(a);
                        anexos.add(a);
                    }
                }
                conj.setAnexos(anxs);
                p.setConjuge(conj);
            }
        }

        return p;
    }

    public static void setPrivateField(final Object object, final String fieldName, final Object newValue) {
        if (null == object) {
            throw new NullPointerException("object não pode ser null!");
        }
        if (null == fieldName) {
            throw new NullPointerException("fieldName não pode ser null!");
        }

        Class<?> klass = object.getClass();

        Field field = null;
        try {
            field = klass.getDeclaredField(fieldName);

            field.setAccessible(true);
            field.set(object, newValue);

        } catch (SecurityException e) {
        } catch (NoSuchFieldException e) {
        } catch (IllegalArgumentException e) {
        } catch (IllegalAccessException e) {
        }
    }

    public static Anexo copiaAnexo(Anexo anexo) {
        Anexo anx = new Anexo();
        anx.setCod(anexo.getCod());
        anx.setNome(anexo.getNome());
        anx.setNomeExibicao(anexo.getNomeExibicao());
        anx.setTipo(anexo.getTipo());
        anx.setTipoAnexo(anexo.getTipoAnexo());
        anx.setUUID(anexo.getUUID());
        anx.setUrl(anexo.getUrl());
        return anx;
    }

    public static EntidadeGenerica setCamposNulos(EntidadeGenerica entidade) {
        entidade.setAtivo(true);
        entidade.setDataAtualizacao(null);
        entidade.setDataCriacao(null);
        entidade.setUsuarioAtualizacao(null);
        entidade.setUsuarioCriacao(null);
        entidade.setVersao(1);
        return entidade;
    }

    public static byte[] getBytes(File file) {
        int length = (int) file.length();
        byte[] bytes = new byte[length];
        FileInputStream inFile = null;
        try {
            inFile = new FileInputStream(file);
            inFile.read(bytes, 0, length);

        } catch (IOException ioex) {
            System.err.println("File not found!");
        }

        return bytes;
    }

    public static Proprietario setProprietarioInativo(Proprietario p) {
        p.setAtivo(false);
        if (p.getEndereco() != null) {
            p.getEndereco().setAtivo(false);
        }
        if (p.getAnexos() != null) {
            for (Anexo anexo : p.getAnexos()) {
                anexo.setAtivo(false);
            }
        }
        if (p.getConjuge() != null) {
            p.getConjuge().setAtivo(false);

            if (p.getConjuge().getEndereco() != null) {
                p.getConjuge().getEndereco().setAtivo(false);
            }
            if (p.getConjuge().getAnexos() != null) {
                for (Anexo anexo : p.getConjuge().getAnexos()) {
                    anexo.setAtivo(false);
                }
            }
        }

        return p;
    }
}
